Crate datafusion_expr

DataFusion is an extensible query execution framework that uses Apache Arrow as its in-memory format.

This crate is a submodule of DataFusion that provides types representing logical query plans (LogicalPlan) and logical expressions (Expr) as well as utilities for working with these types.

The expr_fn module contains functions for creating expressions.

Re-exports

• pub use aggregate_function::AggregateFunction;
• pub use expr::Between;
• pub use expr::BinaryExpr;
• pub use expr::Case;
• pub use expr::Cast;
• pub use expr::Expr;
• pub use expr::GetFieldAccess;
• pub use expr::GetIndexedField;
• pub use expr::GroupingSet;
• pub use expr::Like;
• pub use expr::TryCast;
• pub use expr_schema::ExprSchemable;
• pub use function::AccumulatorFactoryFunction;
• pub use function::PartitionEvaluatorFactory;
• pub use function::ReturnTypeFunction;
• pub use function::ScalarFunctionImplementation;
• pub use function::StateTypeFunction;
• pub use window_frame::WindowFrame;
• pub use window_frame::WindowFrameBound;
• pub use window_frame::WindowFrameUnits;
• pub use window_function::BuiltInWindowFunction;
• pub use window_function::WindowFunction;
• pub use expr_fn::*;
• pub use logical_plan::*;

Modules

• aggregate_function
  Aggregate function module contains all built-in aggregate functions definitions
• array_expressions
• conditional_expressions
  Conditional expressions
• expr
  Expr module contains core type definition for Expr.
• expr_fn
  Functions for creating logical expressions
• expr_rewriter
  Expression rewriter
• expr_schema
• field_util
  Utility functions for complex field access
• function
  Function module contains typing and signature for built-in and user defined functions.
• logical_plan
• struct_expressions
• tree_node
  Tree node implementation for logical expr and logical plan
• type_coercion
  Type coercion rules for DataFusion
• utils
  Expression utilities
• window_frame
  Window frame module
• window_function
  Window functions provide the ability to perform calculations across sets of rows that are related to the current query row.
• window_state
  Structures used to hold window function state (for implementing WindowUDFs)

Macros

• expr_vec_fmt

Structs

• AggregateUDF
  Logical representation of a user-defined aggregate function (UDAF).
• ScalarUDF
  Logical representation of a UDF.
• Signature
  The signature of a function defines the supported argument types and its volatility.
• WindowUDF
  Logical representation of a user-defined window function (UDWF) A UDWF is different from a UDF in that it is stateful across batches.

Enums

• BuiltinScalarFunction
  Enum of all built-in scalar functions
• ColumnarValue
  Represents the result of evaluating an expression: either a single ScalarValue or an [ArrayRef].
• Operator
  Operators applied to expressions
• TableProviderFilterPushDown
  Indicates whether and how a filter expression can be handled by a TableProvider for table scans.
• TableType
  Indicates the type of this table for metadata/catalog purposes.
• TypeSignature
  A function’s type signature, which defines the function’s supported argument types.
• Volatility
  A function’s volatility, which defines the functions eligibility for certain optimizations

Statics

• SUPPORTED_NULLIF_TYPES
  Currently supported types by the nullif function. The order of these types correspond to the order on which coercion applies This should thus be from least informative to most informative

Traits

• Accumulator
  Describes an aggregate functions’s state.
• Literal
  Trait for converting a type to a Literal literal expression.
• PartitionEvaluator
  Partition evaluator for Window Functions
• TableSource
  The TableSource trait is used during logical query planning and optimizations and provides access to schema information and filter push-down capabilities. This trait provides a subset of the functionality of the TableProvider trait in the core datafusion crate. The TableProvider trait provides additional capabilities needed for physical query execution (such as the ability to perform a scan). The reason for having two separate traits is to avoid having the logical plan code be dependent on the DataFusion execution engine. Other projects may want to use DataFusion’s logical plans and have their own execution engine.
• TimestampLiteral
  Trait for converting a type to a literal timestamp

Functions

• lit
  Create a literal expression
• lit_timestamp_nano
  Create a literal timestamp expression